<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html lang="en">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>LCOV - lcov.info - src/lib/src/expansion_tile_list.dart</title>
  <link rel="stylesheet" type="text/css" href="../../../gcov.css">
</head>

<body>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="title">LCOV - code coverage report</td></tr>
            <tr><td class="ruler"><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>

            <tr>
              <td width="100%">
                <table cellpadding=1 border=0 width="100%">
          <tr>
            <td width="10%" class="headerItem">Current view:</td>
            <td width="10%" class="headerValue"><a href="../../../index.html">top level</a> - <a href="index.html">src/lib/src</a> - expansion_tile_list.dart<span style="font-size: 80%;"> (source / <a href="expansion_tile_list.dart.func-c.html">functions</a>)</span></td>
            <td width="5%"></td>
            <td width="5%"></td>
            <td width="5%" class="headerCovTableHead">Coverage</td>
            <td width="5%" class="headerCovTableHead" title="Covered + Uncovered code">Total</td>
            <td width="5%" class="headerCovTableHead" title="Exercised code only">Hit</td>
          </tr>
          <tr>
            <td class="headerItem">Test:</td>
            <td class="headerValue">lcov.info</td>
            <td></td>
            <td class="headerItem">Lines:</td>
            <td class="headerCovTableEntryLo">54.5&nbsp;%</td>
            <td class="headerCovTableEntry">123</td>
            <td class="headerCovTableEntry">67</td>
          </tr>
          <tr>
            <td class="headerItem">Test Date:</td>
            <td class="headerValue">2024-04-20 01:45:39</td>
            <td></td>
            <td class="headerItem">Functions:</td>
            <td class="headerCovTableEntryHi">-</td>
            <td class="headerCovTableEntry">0</td>
            <td class="headerCovTableEntry">0</td>
          </tr>
                  <tr><td><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>
                </table>
              </td>
            </tr>

            <tr><td class="ruler"><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>
          </table>

          <table cellpadding=0 cellspacing=0 border=0>
            <tr>
              <td><br></td>
            </tr>
            <tr>
              <td>
<pre class="sourceHeading">            Line data    Source code</pre>
<pre class="source">
<span id="L1"><span class="lineNum">       1</span>              : import 'package:flutter/material.dart';</span>
<span id="L2"><span class="lineNum">       2</span>              : </span>
<span id="L3"><span class="lineNum">       3</span>              : import 'expansion_tile_extension.dart';</span>
<span id="L4"><span class="lineNum">       4</span>              : </span>
<span id="L5"><span class="lineNum">       5</span>              : /// Signature for the listener callback that's called when an [ExpansionTile] is</span>
<span id="L6"><span class="lineNum">       6</span>              : /// expanded or collapsed.</span>
<span id="L7"><span class="lineNum">       7</span>              : ///</span>
<span id="L8"><span class="lineNum">       8</span>              : /// The position of the panel within an [ExpansionTileList] is given by</span>
<span id="L9"><span class="lineNum">       9</span>              : /// [tileIndex].</span>
<span id="L10"><span class="lineNum">      10</span>              : typedef ExpansionTileCallback = void Function(int tileIndex, bool isExpanded);</span>
<span id="L11"><span class="lineNum">      11</span>              : </span>
<span id="L12"><span class="lineNum">      12</span>              : /// Enum representing the expansion behavior of the [ExpansionTileList].</span>
<span id="L13"><span class="lineNum">      13</span>              : ///</span>
<span id="L14"><span class="lineNum">      14</span>              : /// - [atLeastOne]: At least one tile in the list should be expanded.</span>
<span id="L15"><span class="lineNum">      15</span>              : /// - [atMostOne]: At most one tile in the list can be expanded.</span>
<span id="L16"><span class="lineNum">      16</span>              : /// - [exactlyOne]: Exactly one tile in the list should be expanded.</span>
<span id="L17"><span class="lineNum">      17</span>              : /// - [any]: Any number of tiles in the list can be expanded</span>
<span id="L18"><span class="lineNum">      18</span>              : enum ExpansionType {</span>
<span id="L19"><span class="lineNum">      19</span>              :   atLeastOne,</span>
<span id="L20"><span class="lineNum">      20</span>              :   atMostOne,</span>
<span id="L21"><span class="lineNum">      21</span>              :   exactlyOne,</span>
<span id="L22"><span class="lineNum">      22</span>              :   any;</span>
<span id="L23"><span class="lineNum">      23</span>              : </span>
<span id="L24"><span class="lineNum">      24</span>              :   /// Returns true if the expansion type allows multiple tiles to be expanded.</span>
<span id="L25"><span class="lineNum">      25</span> <span class="tlaUNC tlaBgUNC">           0 :   bool get isMultipleExpansion =&gt;</span></span>
<span id="L26"><span class="lineNum">      26</span> <span class="tlaUNC">           0 :       this == ExpansionType.any || this == ExpansionType.atLeastOne;</span></span>
<span id="L27"><span class="lineNum">      27</span>              : </span>
<span id="L28"><span class="lineNum">      28</span>              :   /// Returns true if the expansion type allows only a single tile to be expanded.</span>
<span id="L29"><span class="lineNum">      29</span> <span class="tlaGNC tlaBgGNC">           1 :   bool get isSingleExpansion =&gt;</span></span>
<span id="L30"><span class="lineNum">      30</span> <span class="tlaGNC">           2 :       this == ExpansionType.atMostOne || this == ExpansionType.exactlyOne;</span></span>
<span id="L31"><span class="lineNum">      31</span>              : }</span>
<span id="L32"><span class="lineNum">      32</span>              : </span>
<span id="L33"><span class="lineNum">      33</span>              : /// A widget that manages a list of [ExpansionTile]s.</span>
<span id="L34"><span class="lineNum">      34</span>              : ///</span>
<span id="L35"><span class="lineNum">      35</span>              : /// The [ExpansionTileList] takes a list of [ExpansionTile]s and an [ExpansionType]</span>
<span id="L36"><span class="lineNum">      36</span>              : /// to manage the expansion behavior of the list. It also accepts optional parameters</span>
<span id="L37"><span class="lineNum">      37</span>              : /// for initially expanded indexes, a callback for expansion changes, a gap size between tiles,</span>
<span id="L38"><span class="lineNum">      38</span>              : /// a custom builder for the tile, and a controller for the list.</span>
<span id="L39"><span class="lineNum">      39</span>              : ///</span>
<span id="L40"><span class="lineNum">      40</span>              : /// The [ExpansionType] determines how many tiles can be expanded at once. It can be set to</span>
<span id="L41"><span class="lineNum">      41</span>              : /// allow multiple tiles to be expanded at the same time, or restrict it to a single tile.</span>
<span id="L42"><span class="lineNum">      42</span>              : ///</span>
<span id="L43"><span class="lineNum">      43</span>              : /// The [initialExpandedIndexes] or [initialExpandedIndex] can be used to specify which tiles</span>
<span id="L44"><span class="lineNum">      44</span>              : /// are expanded when the list is first created.</span>
<span id="L45"><span class="lineNum">      45</span>              : ///</span>
<span id="L46"><span class="lineNum">      46</span>              : /// The [onExpansionChanged] callback is called whenever a tile is expanded or collapsed.</span>
<span id="L47"><span class="lineNum">      47</span>              : ///</span>
<span id="L48"><span class="lineNum">      48</span>              : /// The [tileGapSize] can be used to specify a gap between the tiles in the list.</span>
<span id="L49"><span class="lineNum">      49</span>              : ///</span>
<span id="L50"><span class="lineNum">      50</span>              : /// The [builder] can be used to customize the appearance of the tiles.</span>
<span id="L51"><span class="lineNum">      51</span>              : ///</span>
<span id="L52"><span class="lineNum">      52</span>              : /// The [controller] can be used to programmatically control the expansion of the tiles.</span>
<span id="L53"><span class="lineNum">      53</span>              : class ExpansionTileList extends StatefulWidget {</span>
<span id="L54"><span class="lineNum">      54</span> <span class="tlaGNC">           1 :   const ExpansionTileList._({</span></span>
<span id="L55"><span class="lineNum">      55</span>              :     super.key,</span>
<span id="L56"><span class="lineNum">      56</span>              :     required this.children,</span>
<span id="L57"><span class="lineNum">      57</span>              :     required this.expansionType,</span>
<span id="L58"><span class="lineNum">      58</span>              :     List&lt;int&gt; initialExpandedIndexes = const &lt;int&gt;[],</span>
<span id="L59"><span class="lineNum">      59</span>              :     int? initialExpandedIndex,</span>
<span id="L60"><span class="lineNum">      60</span>              :     this.onExpansionChanged,</span>
<span id="L61"><span class="lineNum">      61</span>              :     this.tileGapSize = 0.0,</span>
<span id="L62"><span class="lineNum">      62</span>              :     this.builder,</span>
<span id="L63"><span class="lineNum">      63</span>              :     this.controller,</span>
<span id="L64"><span class="lineNum">      64</span> <span class="tlaGNC">           2 :   })  : assert(tileGapSize &gt;= 0.0,</span></span>
<span id="L65"><span class="lineNum">      65</span>              :   'Error: Please set the tileGapSize of ExpansionTileList must be &gt;= 0'),</span>
<span id="L66"><span class="lineNum">      66</span>              :         assert(</span>
<span id="L67"><span class="lineNum">      67</span> <span class="tlaGNC">           2 :         (expansionType == ExpansionType.any ||</span></span>
<span id="L68"><span class="lineNum">      68</span> <span class="tlaUNC tlaBgUNC">           0 :             expansionType == ExpansionType.atLeastOne) ||</span></span>
<span id="L69"><span class="lineNum">      69</span> <span class="tlaUNC">           0 :             (expansionType == ExpansionType.atMostOne &amp;&amp;</span></span>
<span id="L70"><span class="lineNum">      70</span> <span class="tlaUNC">           0 :                 initialExpandedIndexes.length &lt;= 1) ||</span></span>
<span id="L71"><span class="lineNum">      71</span> <span class="tlaUNC">           0 :             (expansionType == ExpansionType.exactlyOne &amp;&amp;</span></span>
<span id="L72"><span class="lineNum">      72</span> <span class="tlaUNC">           0 :                 (initialExpandedIndexes.length &lt;= 1 ||</span></span>
<span id="L73"><span class="lineNum">      73</span>              :                     initialExpandedIndex != null)),</span>
<span id="L74"><span class="lineNum">      74</span>              :         'Error: Please set the initialExpandedIndexes for the provided ExpansionType.atMostOne or ExpansionType.exactlyOn must be &lt;= 1 or use initialExpandedIndex instead'),</span>
<span id="L75"><span class="lineNum">      75</span>              :         _initialExpandedIndexes = initialExpandedIndexes,</span>
<span id="L76"><span class="lineNum">      76</span>              :         _initialExpandedIndex = initialExpandedIndex;</span>
<span id="L77"><span class="lineNum">      77</span>              : </span>
<span id="L78"><span class="lineNum">      78</span>              :   /// Creates a list of [ExpansionTile]s that can have any number of tiles expanded at once.</span>
<span id="L79"><span class="lineNum">      79</span> <span class="tlaGNC tlaBgGNC">           1 :   const ExpansionTileList({</span></span>
<span id="L80"><span class="lineNum">      80</span>              :     Key? key,</span>
<span id="L81"><span class="lineNum">      81</span>              :     required List&lt;ExpansionTile&gt; children,</span>
<span id="L82"><span class="lineNum">      82</span>              :     List&lt;int&gt; initialExpandedIndexes = const &lt;int&gt;[],</span>
<span id="L83"><span class="lineNum">      83</span>              :     ExpansionTileCallback? onExpansionChanged,</span>
<span id="L84"><span class="lineNum">      84</span>              :     double tileGapSize = 0.0,</span>
<span id="L85"><span class="lineNum">      85</span>              :     ValueWidgetBuilder&lt;int&gt;? builder,</span>
<span id="L86"><span class="lineNum">      86</span>              :     ExpansionTileListController? controller,</span>
<span id="L87"><span class="lineNum">      87</span> <span class="tlaGNC">           1 :   }) : this._(</span></span>
<span id="L88"><span class="lineNum">      88</span>              :     key: key,</span>
<span id="L89"><span class="lineNum">      89</span>              :     children: children,</span>
<span id="L90"><span class="lineNum">      90</span>              :     expansionType: ExpansionType.any,</span>
<span id="L91"><span class="lineNum">      91</span>              :     initialExpandedIndexes: initialExpandedIndexes,</span>
<span id="L92"><span class="lineNum">      92</span>              :     onExpansionChanged: onExpansionChanged,</span>
<span id="L93"><span class="lineNum">      93</span>              :     tileGapSize: tileGapSize,</span>
<span id="L94"><span class="lineNum">      94</span>              :     builder: builder,</span>
<span id="L95"><span class="lineNum">      95</span>              :     controller: controller,</span>
<span id="L96"><span class="lineNum">      96</span>              :   );</span>
<span id="L97"><span class="lineNum">      97</span>              : </span>
<span id="L98"><span class="lineNum">      98</span>              :   /// Creates a list of [ExpansionTile]s that can have at least one tile expanded at all times.</span>
<span id="L99"><span class="lineNum">      99</span> <span class="tlaUNC tlaBgUNC">           0 :   const ExpansionTileList.radio({</span></span>
<span id="L100"><span class="lineNum">     100</span>              :     Key? key,</span>
<span id="L101"><span class="lineNum">     101</span>              :     required List&lt;ExpansionTile&gt; children,</span>
<span id="L102"><span class="lineNum">     102</span>              :     int? initialExpandedIndex,</span>
<span id="L103"><span class="lineNum">     103</span>              :     ExpansionTileCallback? onExpansionChanged,</span>
<span id="L104"><span class="lineNum">     104</span>              :     double tileGapSize = 0.0,</span>
<span id="L105"><span class="lineNum">     105</span>              :     ValueWidgetBuilder&lt;int&gt;? builder,</span>
<span id="L106"><span class="lineNum">     106</span>              :     ExpansionTileListController? controller,</span>
<span id="L107"><span class="lineNum">     107</span> <span class="tlaUNC">           0 :   }) : this._(</span></span>
<span id="L108"><span class="lineNum">     108</span>              :     key: key,</span>
<span id="L109"><span class="lineNum">     109</span>              :     children: children,</span>
<span id="L110"><span class="lineNum">     110</span>              :     expansionType: ExpansionType.atMostOne,</span>
<span id="L111"><span class="lineNum">     111</span>              :     initialExpandedIndex: initialExpandedIndex,</span>
<span id="L112"><span class="lineNum">     112</span>              :     onExpansionChanged: onExpansionChanged,</span>
<span id="L113"><span class="lineNum">     113</span>              :     tileGapSize: tileGapSize,</span>
<span id="L114"><span class="lineNum">     114</span>              :     builder: builder,</span>
<span id="L115"><span class="lineNum">     115</span>              :     controller: controller,</span>
<span id="L116"><span class="lineNum">     116</span>              :   );</span>
<span id="L117"><span class="lineNum">     117</span>              : </span>
<span id="L118"><span class="lineNum">     118</span>              :   /// The list of [ExpansionTile]s that are managed by this widget.</span>
<span id="L119"><span class="lineNum">     119</span>              :   final List&lt;ExpansionTile&gt; children;</span>
<span id="L120"><span class="lineNum">     120</span>              : </span>
<span id="L121"><span class="lineNum">     121</span>              :   /// The type of expansion: at most one, exactly one, or any number of tiles can be expanded at a time.</span>
<span id="L122"><span class="lineNum">     122</span>              :   final ExpansionType expansionType;</span>
<span id="L123"><span class="lineNum">     123</span>              : </span>
<span id="L124"><span class="lineNum">     124</span>              :   /// Called whenever a tile is expanded or collapsed.</span>
<span id="L125"><span class="lineNum">     125</span>              :   final ExpansionTileCallback? onExpansionChanged;</span>
<span id="L126"><span class="lineNum">     126</span>              : </span>
<span id="L127"><span class="lineNum">     127</span>              :   /// The size of the gap between the tiles in the list.</span>
<span id="L128"><span class="lineNum">     128</span>              :   final double tileGapSize;</span>
<span id="L129"><span class="lineNum">     129</span>              : </span>
<span id="L130"><span class="lineNum">     130</span>              :   /// A builder that can be used to customize the appearance of the tiles.</span>
<span id="L131"><span class="lineNum">     131</span>              :   final ValueWidgetBuilder&lt;int&gt;? builder;</span>
<span id="L132"><span class="lineNum">     132</span>              : </span>
<span id="L133"><span class="lineNum">     133</span>              :   /// A controller that can be used to programmatically control the expansion of the tiles.</span>
<span id="L134"><span class="lineNum">     134</span>              :   final ExpansionTileListController? controller;</span>
<span id="L135"><span class="lineNum">     135</span>              : </span>
<span id="L136"><span class="lineNum">     136</span>              :   /// The indexes of the tiles that are initially expanded. If empty, no tiles are initially expanded.</span>
<span id="L137"><span class="lineNum">     137</span>              :   /// For multiple: [ExpansionType.any] , [ExpansionType.atLeastOne].</span>
<span id="L138"><span class="lineNum">     138</span>              :   final List&lt;int&gt; _initialExpandedIndexes;</span>
<span id="L139"><span class="lineNum">     139</span>              : </span>
<span id="L140"><span class="lineNum">     140</span>              :   /// The index of the tile that is initially expanded. If null, no tiles are initially expanded.</span>
<span id="L141"><span class="lineNum">     141</span>              :   /// For single: [ExpansionType.exactlyOne] , [ExpansionType.atMostOne].</span>
<span id="L142"><span class="lineNum">     142</span>              :   final int? _initialExpandedIndex;</span>
<span id="L143"><span class="lineNum">     143</span>              : </span>
<span id="L144"><span class="lineNum">     144</span> <span class="tlaUNC">           0 :   List&lt;int&gt; get initialExpandedIndexes =&gt; expansionType.isMultipleExpansion</span></span>
<span id="L145"><span class="lineNum">     145</span> <span class="tlaUNC">           0 :       ? (_initialExpandedIndexes.isNotEmpty</span></span>
<span id="L146"><span class="lineNum">     146</span> <span class="tlaUNC">           0 :       ? _initialExpandedIndexes</span></span>
<span id="L147"><span class="lineNum">     147</span> <span class="tlaUNC">           0 :       : (_initialExpandedIndex != null ? [_initialExpandedIndex] : []))</span></span>
<span id="L148"><span class="lineNum">     148</span> <span class="tlaUNC">           0 :       : (_initialExpandedIndex == null</span></span>
<span id="L149"><span class="lineNum">     149</span> <span class="tlaUNC">           0 :       ? (_initialExpandedIndexes.isNotEmpty</span></span>
<span id="L150"><span class="lineNum">     150</span> <span class="tlaUNC">           0 :       ? [_initialExpandedIndexes[0]]</span></span>
<span id="L151"><span class="lineNum">     151</span> <span class="tlaUNC">           0 :       : [])</span></span>
<span id="L152"><span class="lineNum">     152</span> <span class="tlaUNC">           0 :       : [_initialExpandedIndex]);</span></span>
<span id="L153"><span class="lineNum">     153</span>              : </span>
<span id="L154"><span class="lineNum">     154</span>              :   /// Creates the mutable state for this widget at a given location in the tree.</span>
<span id="L155"><span class="lineNum">     155</span>              :   ///</span>
<span id="L156"><span class="lineNum">     156</span>              :   /// This method is called immediately after the widget is inserted in the tree</span>
<span id="L157"><span class="lineNum">     157</span>              :   /// and must return a separate [State] object for each instance of this widget.</span>
<span id="L158"><span class="lineNum">     158</span>              :   /// In this case, it returns an instance of [_ExpansionTileListState].</span>
<span id="L159"><span class="lineNum">     159</span> <span class="tlaGNC tlaBgGNC">           1 :   @override</span></span>
<span id="L160"><span class="lineNum">     160</span> <span class="tlaGNC">           1 :   State&lt;ExpansionTileList&gt; createState() =&gt; _ExpansionTileListState();</span></span>
<span id="L161"><span class="lineNum">     161</span>              : }</span>
<span id="L162"><span class="lineNum">     162</span>              : </span>
<span id="L163"><span class="lineNum">     163</span>              : /// [_ExpansionTileListState] is the [State] object for the [ExpansionTileList] widget.</span>
<span id="L164"><span class="lineNum">     164</span>              : ///</span>
<span id="L165"><span class="lineNum">     165</span>              : /// This class manages the stateful properties for the [ExpansionTileList] widget.</span>
<span id="L166"><span class="lineNum">     166</span>              : /// It maintains the state of the expansion tiles in the list, such as which tiles are expanded.</span>
<span id="L167"><span class="lineNum">     167</span>              : ///</span>
<span id="L168"><span class="lineNum">     168</span>              : /// This class is private to the library as it starts with an underscore.</span>
<span id="L169"><span class="lineNum">     169</span>              : class _ExpansionTileListState extends State&lt;ExpansionTileList&gt; {</span>
<span id="L170"><span class="lineNum">     170</span>              :   late final ExpansionTileListController _listController;</span>
<span id="L171"><span class="lineNum">     171</span>              :   late final List&lt;ExpansionTile&gt; _children;</span>
<span id="L172"><span class="lineNum">     172</span>              :   bool _isExpansionChanging = false;</span>
<span id="L173"><span class="lineNum">     173</span>              : </span>
<span id="L174"><span class="lineNum">     174</span> <span class="tlaGNC">           1 :   @override</span></span>
<span id="L175"><span class="lineNum">     175</span>              :   void initState() {</span>
<span id="L176"><span class="lineNum">     176</span> <span class="tlaGNC">           1 :     super.initState();</span></span>
<span id="L177"><span class="lineNum">     177</span> <span class="tlaGNC">           2 :     _children = [];</span></span>
<span id="L178"><span class="lineNum">     178</span> <span class="tlaGNC">           1 :     _updateExpansionTiles();</span></span>
<span id="L179"><span class="lineNum">     179</span> <span class="tlaGNC">           3 :     assert(widget.controller?._state == null);</span></span>
<span id="L180"><span class="lineNum">     180</span> <span class="tlaGNC">           4 :     _listController = widget.controller ?? ExpansionTileListController();</span></span>
<span id="L181"><span class="lineNum">     181</span> <span class="tlaGNC">           2 :     _listController._state = this;</span></span>
<span id="L182"><span class="lineNum">     182</span>              :   }</span>
<span id="L183"><span class="lineNum">     183</span>              : </span>
<span id="L184"><span class="lineNum">     184</span> <span class="tlaUNC tlaBgUNC">           0 :   @override</span></span>
<span id="L185"><span class="lineNum">     185</span>              :   void didUpdateWidget(ExpansionTileList oldWidget) {</span>
<span id="L186"><span class="lineNum">     186</span> <span class="tlaUNC">           0 :     super.didUpdateWidget(oldWidget);</span></span>
<span id="L187"><span class="lineNum">     187</span> <span class="tlaUNC">           0 :     _updateExpansionTiles(oldWidget.children);</span></span>
<span id="L188"><span class="lineNum">     188</span>              :   }</span>
<span id="L189"><span class="lineNum">     189</span>              : </span>
<span id="L190"><span class="lineNum">     190</span> <span class="tlaGNC tlaBgGNC">           1 :   @override</span></span>
<span id="L191"><span class="lineNum">     191</span>              :   void didChangeDependencies() {</span>
<span id="L192"><span class="lineNum">     192</span> <span class="tlaGNC">           1 :     super.didChangeDependencies();</span></span>
<span id="L193"><span class="lineNum">     193</span>              :   }</span>
<span id="L194"><span class="lineNum">     194</span>              : </span>
<span id="L195"><span class="lineNum">     195</span>              :   /// Disposes the resources used by this state object.</span>
<span id="L196"><span class="lineNum">     196</span>              :   ///</span>
<span id="L197"><span class="lineNum">     197</span>              :   /// This method is called when this state object will never build again.</span>
<span id="L198"><span class="lineNum">     198</span>              :   /// After calling this method, the state object is considered unmounted.</span>
<span id="L199"><span class="lineNum">     199</span> <span class="tlaGNC">           1 :   @override</span></span>
<span id="L200"><span class="lineNum">     200</span>              :   void dispose() {</span>
<span id="L201"><span class="lineNum">     201</span> <span class="tlaGNC">           2 :     _children.clear();</span></span>
<span id="L202"><span class="lineNum">     202</span> <span class="tlaGNC">           2 :     _listController._state = null;</span></span>
<span id="L203"><span class="lineNum">     203</span> <span class="tlaGNC">           1 :     super.dispose();</span></span>
<span id="L204"><span class="lineNum">     204</span>              :   }</span>
<span id="L205"><span class="lineNum">     205</span>              : </span>
<span id="L206"><span class="lineNum">     206</span>              :   /// Describes the part of the user interface represented by this widget.</span>
<span id="L207"><span class="lineNum">     207</span>              :   ///</span>
<span id="L208"><span class="lineNum">     208</span>              :   /// The framework calls this method when this widget is inserted into the tree in</span>
<span id="L209"><span class="lineNum">     209</span>              :   /// a given BuildContext and when the dependencies of this widget change.</span>
<span id="L210"><span class="lineNum">     210</span> <span class="tlaGNC">           1 :   @override</span></span>
<span id="L211"><span class="lineNum">     211</span>              :   Widget build(BuildContext context) {</span>
<span id="L212"><span class="lineNum">     212</span> <span class="tlaGNC">           1 :     return Column(</span></span>
<span id="L213"><span class="lineNum">     213</span> <span class="tlaGNC">           2 :       children: [..._buildChildren()],</span></span>
<span id="L214"><span class="lineNum">     214</span>              :     );</span>
<span id="L215"><span class="lineNum">     215</span>              :   }</span>
<span id="L216"><span class="lineNum">     216</span>              : </span>
<span id="L217"><span class="lineNum">     217</span>              :   /// Builds the children of the [ExpansionTileList].</span>
<span id="L218"><span class="lineNum">     218</span>              :   ///</span>
<span id="L219"><span class="lineNum">     219</span>              :   /// This method is responsible for generating the list of widgets that represent</span>
<span id="L220"><span class="lineNum">     220</span>              :   /// the children of the [ExpansionTileList].</span>
<span id="L221"><span class="lineNum">     221</span> <span class="tlaGNC">           1 :   List&lt;Widget&gt; _buildChildren() {</span></span>
<span id="L222"><span class="lineNum">     222</span> <span class="tlaGNC">           5 :     return List.generate(widget.children.length, (int index) {</span></span>
<span id="L223"><span class="lineNum">     223</span> <span class="tlaGNC">           1 :       return Column(</span></span>
<span id="L224"><span class="lineNum">     224</span> <span class="tlaGNC">           1 :         children: &lt;Widget&gt;[</span></span>
<span id="L225"><span class="lineNum">     225</span> <span class="tlaGNC">           2 :           widget.builder?.call(context, index, _children[index]) ??</span></span>
<span id="L226"><span class="lineNum">     226</span> <span class="tlaGNC">           2 :               _children[index],</span></span>
<span id="L227"><span class="lineNum">     227</span> <span class="tlaGNC">           8 :           if (index &lt; widget.children.length - 1 &amp;&amp; widget.tileGapSize &gt; 0.0)</span></span>
<span id="L228"><span class="lineNum">     228</span> <span class="tlaUNC tlaBgUNC">           0 :             SizedBox(height: widget.tileGapSize),</span></span>
<span id="L229"><span class="lineNum">     229</span>              :         ],</span>
<span id="L230"><span class="lineNum">     230</span>              :       );</span>
<span id="L231"><span class="lineNum">     231</span>              :     });</span>
<span id="L232"><span class="lineNum">     232</span>              :   }</span>
<span id="L233"><span class="lineNum">     233</span>              : </span>
<span id="L234"><span class="lineNum">     234</span>              :   /// Updates the expansion tiles of the [ExpansionTileList].</span>
<span id="L235"><span class="lineNum">     235</span>              :   ///</span>
<span id="L236"><span class="lineNum">     236</span>              :   /// Update the expansion tiles by comparing the old and new children.</span>
<span id="L237"><span class="lineNum">     237</span>              :   /// If the children are the same, the old expansion tiles are reused.</span>
<span id="L238"><span class="lineNum">     238</span>              :   /// If the children are different, the expansion tiles are updated.</span>
<span id="L239"><span class="lineNum">     239</span> <span class="tlaGNC tlaBgGNC">           1 :   void _updateExpansionTiles([List&lt;ExpansionTile&gt;? children]) {</span></span>
<span id="L240"><span class="lineNum">     240</span> <span class="tlaGNC">           1 :     var tiles = List.generate(</span></span>
<span id="L241"><span class="lineNum">     241</span> <span class="tlaGNC">           3 :         widget.children.length,</span></span>
<span id="L242"><span class="lineNum">     242</span> <span class="tlaGNC">           1 :             (index) =&gt; (children != null &amp;&amp;</span></span>
<span id="L243"><span class="lineNum">     243</span> <span class="tlaUNC tlaBgUNC">           0 :             children.length &gt; index &amp;&amp;</span></span>
<span id="L244"><span class="lineNum">     244</span> <span class="tlaUNC">           0 :             children[index] == widget.children[index])</span></span>
<span id="L245"><span class="lineNum">     245</span> <span class="tlaUNC">           0 :             ? _children[index]</span></span>
<span id="L246"><span class="lineNum">     246</span> <span class="tlaGNC tlaBgGNC">           4 :             : widget.children[index].copyWith(</span></span>
<span id="L247"><span class="lineNum">     247</span> <span class="tlaGNC">           1 :             key: /*widget.children[index].key ??*/ GlobalKey(),</span></span>
<span id="L248"><span class="lineNum">     248</span> <span class="tlaGNC">           4 :             controller: widget.children[index].controller ??</span></span>
<span id="L249"><span class="lineNum">     249</span> <span class="tlaGNC">           1 :                 ExpansionTileController(),</span></span>
<span id="L250"><span class="lineNum">     250</span> <span class="tlaGNC">           1 :             onExpansionChanged: (isExpanded) {</span></span>
<span id="L251"><span class="lineNum">     251</span> <span class="tlaGNC">           4 :               widget.children[index].onExpansionChanged?.call(isExpanded);</span></span>
<span id="L252"><span class="lineNum">     252</span> <span class="tlaGNC">           3 :               widget.onExpansionChanged?.call(index, isExpanded);</span></span>
<span id="L253"><span class="lineNum">     253</span> <span class="tlaGNC">           1 :               _updateExpansionChange(index, isExpanded);</span></span>
<span id="L254"><span class="lineNum">     254</span>              :             }));</span>
<span id="L255"><span class="lineNum">     255</span> <span class="tlaGNC">           2 :     _children.clear();</span></span>
<span id="L256"><span class="lineNum">     256</span> <span class="tlaGNC">           2 :     _children.addAll(tiles);</span></span>
<span id="L257"><span class="lineNum">     257</span>              :   }</span>
<span id="L258"><span class="lineNum">     258</span>              : </span>
<span id="L259"><span class="lineNum">     259</span>              :   /// Updates the expansion state of the tile at the given [index].</span>
<span id="L260"><span class="lineNum">     260</span>              :   ///</span>
<span id="L261"><span class="lineNum">     261</span>              :   /// This method is called when the expansion state of a tile changes.</span>
<span id="L262"><span class="lineNum">     262</span>              :   /// If the tile is not expanded ([isExpanded] is false), this method returns early.</span>
<span id="L263"><span class="lineNum">     263</span>              :   /// If the [ExpansionTileList] is set to single expansion mode, it collapses all other tiles.</span>
<span id="L264"><span class="lineNum">     264</span>              :   ///</span>
<span id="L265"><span class="lineNum">     265</span>              :   /// [index] is the index of the tile in the list.</span>
<span id="L266"><span class="lineNum">     266</span>              :   /// [isExpanded] is the new expansion state of the tile.</span>
<span id="L267"><span class="lineNum">     267</span> <span class="tlaGNC">           1 :   void _updateExpansionChange(int index, bool isExpanded) {</span></span>
<span id="L268"><span class="lineNum">     268</span>              :     if (!isExpanded) {</span>
<span id="L269"><span class="lineNum">     269</span>              :       return;</span>
<span id="L270"><span class="lineNum">     270</span>              :     }</span>
<span id="L271"><span class="lineNum">     271</span> <span class="tlaGNC">           1 :     _isExpansionChanging = true;</span></span>
<span id="L272"><span class="lineNum">     272</span> <span class="tlaGNC">           3 :     if (widget.expansionType.isSingleExpansion) {</span></span>
<span id="L273"><span class="lineNum">     273</span> <span class="tlaUNC tlaBgUNC">           0 :       Future.microtask(() {</span></span>
<span id="L274"><span class="lineNum">     274</span> <span class="tlaUNC">           0 :         for (int i = 0; i &lt; _children.length; i++) {</span></span>
<span id="L275"><span class="lineNum">     275</span> <span class="tlaUNC">           0 :           if (i != index &amp;&amp; _children[i].enabled) {</span></span>
<span id="L276"><span class="lineNum">     276</span> <span class="tlaUNC">           0 :             _children[i].controller?.collapse();</span></span>
<span id="L277"><span class="lineNum">     277</span>              :           }</span>
<span id="L278"><span class="lineNum">     278</span>              :         }</span>
<span id="L279"><span class="lineNum">     279</span> <span class="tlaUNC">           0 :         _isExpansionChanging = false;</span></span>
<span id="L280"><span class="lineNum">     280</span>              :       });</span>
<span id="L281"><span class="lineNum">     281</span>              :     }</span>
<span id="L282"><span class="lineNum">     282</span>              :   }</span>
<span id="L283"><span class="lineNum">     283</span>              : </span>
<span id="L284"><span class="lineNum">     284</span>              :   /// Toggles the expansion state of all tiles in the list.</span>
<span id="L285"><span class="lineNum">     285</span>              :   ///</span>
<span id="L286"><span class="lineNum">     286</span>              :   /// If [expand] is true, all tiles are expanded.</span>
<span id="L287"><span class="lineNum">     287</span>              :   /// If [expand] is false, all tiles are collapsed.</span>
<span id="L288"><span class="lineNum">     288</span>              :   /// If [expand] is null, the expansion state of all tiles is reversed.</span>
<span id="L289"><span class="lineNum">     289</span> <span class="tlaGNC tlaBgGNC">           1 :   void _toggleAll([bool? expand]) {</span></span>
<span id="L290"><span class="lineNum">     290</span> <span class="tlaGNC">           4 :     for (int i = 0; i &lt; _children.length; i++) {</span></span>
<span id="L291"><span class="lineNum">     291</span>              :       if (expand != null) {</span>
<span id="L292"><span class="lineNum">     292</span>              :         if (expand) {</span>
<span id="L293"><span class="lineNum">     293</span> <span class="tlaGNC">           4 :           _children[i].controller?.expand();</span></span>
<span id="L294"><span class="lineNum">     294</span>              :         } else {</span>
<span id="L295"><span class="lineNum">     295</span> <span class="tlaGNC">           4 :           _children[i].controller?.collapse();</span></span>
<span id="L296"><span class="lineNum">     296</span>              :         }</span>
<span id="L297"><span class="lineNum">     297</span>              :       } else {</span>
<span id="L298"><span class="lineNum">     298</span> <span class="tlaUNC tlaBgUNC">           0 :         _toggle(i);</span></span>
<span id="L299"><span class="lineNum">     299</span>              :       }</span>
<span id="L300"><span class="lineNum">     300</span>              :     }</span>
<span id="L301"><span class="lineNum">     301</span>              :   }</span>
<span id="L302"><span class="lineNum">     302</span>              : </span>
<span id="L303"><span class="lineNum">     303</span>              :   /// Toggles the expansion state of the tile at the given [index].</span>
<span id="L304"><span class="lineNum">     304</span>              :   ///</span>
<span id="L305"><span class="lineNum">     305</span>              :   /// If the tile is expanded, it is collapsed.</span>
<span id="L306"><span class="lineNum">     306</span>              :   /// If the tile is collapsed, it is expanded.</span>
<span id="L307"><span class="lineNum">     307</span>              :   ///</span>
<span id="L308"><span class="lineNum">     308</span>              :   /// [index] is the index of the tile in the list.</span>
<span id="L309"><span class="lineNum">     309</span> <span class="tlaGNC tlaBgGNC">           1 :   void _toggle(int index) {</span></span>
<span id="L310"><span class="lineNum">     310</span>              :     var controller =</span>
<span id="L311"><span class="lineNum">     311</span> <span class="tlaGNC">           6 :     _children.length &gt; index ? _children[index].controller : null;</span></span>
<span id="L312"><span class="lineNum">     312</span>              :     if (controller != null) {</span>
<span id="L313"><span class="lineNum">     313</span> <span class="tlaGNC">           1 :       if (controller.isExpanded) {</span></span>
<span id="L314"><span class="lineNum">     314</span> <span class="tlaUNC tlaBgUNC">           0 :         controller.collapse();</span></span>
<span id="L315"><span class="lineNum">     315</span>              :       } else {</span>
<span id="L316"><span class="lineNum">     316</span> <span class="tlaGNC tlaBgGNC">           1 :         controller.expand();</span></span>
<span id="L317"><span class="lineNum">     317</span>              :       }</span>
<span id="L318"><span class="lineNum">     318</span>              :     }</span>
<span id="L319"><span class="lineNum">     319</span>              :   }</span>
<span id="L320"><span class="lineNum">     320</span>              : }</span>
<span id="L321"><span class="lineNum">     321</span>              : </span>
<span id="L322"><span class="lineNum">     322</span>              : /// `ExpansionTileListController` is a controller class that provides methods</span>
<span id="L323"><span class="lineNum">     323</span>              : /// to programmatically control the state of tiles in an `ExpansionTileList`.</span>
<span id="L324"><span class="lineNum">     324</span>              : ///</span>
<span id="L325"><span class="lineNum">     325</span>              : /// It provides methods to expand, collapse, and toggle the state of individual tiles</span>
<span id="L326"><span class="lineNum">     326</span>              : /// as well as all tiles in the list.</span>
<span id="L327"><span class="lineNum">     327</span>              : ///</span>
<span id="L328"><span class="lineNum">     328</span>              : /// The `toggle(int index)` method is used to toggle the state of the tile at the given index.</span>
<span id="L329"><span class="lineNum">     329</span>              : ///</span>
<span id="L330"><span class="lineNum">     330</span>              : /// The `expandAll()` method is used to expand all the tiles in the list.</span>
<span id="L331"><span class="lineNum">     331</span>              : ///</span>
<span id="L332"><span class="lineNum">     332</span>              : /// The `collapseAll()` method is used to collapse all the tiles in the list.</span>
<span id="L333"><span class="lineNum">     333</span>              : ///</span>
<span id="L334"><span class="lineNum">     334</span>              : /// The `maybeOf(BuildContext context)` method is used to find the `ExpansionTileListController`</span>
<span id="L335"><span class="lineNum">     335</span>              : /// for the closest `ExpansionTileList` instance that encloses the given context.</span>
<span id="L336"><span class="lineNum">     336</span>              : ///</span>
<span id="L337"><span class="lineNum">     337</span>              : /// Note: Before using these methods, make sure that the `ExpansionTileListController` is ready.</span>
<span id="L338"><span class="lineNum">     338</span>              : /// If the controller is not ready, an assertion error will be thrown.</span>
<span id="L339"><span class="lineNum">     339</span>              : class ExpansionTileListController {</span>
<span id="L340"><span class="lineNum">     340</span> <span class="tlaGNC">           1 :   ExpansionTileListController();</span></span>
<span id="L341"><span class="lineNum">     341</span>              : </span>
<span id="L342"><span class="lineNum">     342</span>              :   _ExpansionTileListState? _state;</span>
<span id="L343"><span class="lineNum">     343</span>              : </span>
<span id="L344"><span class="lineNum">     344</span> <span class="tlaUNC tlaBgUNC">           0 :   bool isExpanded(int index) {</span></span>
<span id="L345"><span class="lineNum">     345</span> <span class="tlaUNC">           0 :     assert(_state != null, 'Error: ExpansionTileListController is not ready');</span></span>
<span id="L346"><span class="lineNum">     346</span> <span class="tlaUNC">           0 :     return _state!._children.length &gt; index &amp;&amp;</span></span>
<span id="L347"><span class="lineNum">     347</span> <span class="tlaUNC">           0 :         (_state!._children[index].controller?.isExpanded ?? false);</span></span>
<span id="L348"><span class="lineNum">     348</span>              :   }</span>
<span id="L349"><span class="lineNum">     349</span>              : </span>
<span id="L350"><span class="lineNum">     350</span>              :   /// Checks if the tile at the given index is expanded.</span>
<span id="L351"><span class="lineNum">     351</span>              :   ///</span>
<span id="L352"><span class="lineNum">     352</span>              :   /// Returns `true` if the tile is expanded, `false` otherwise.</span>
<span id="L353"><span class="lineNum">     353</span>              :   /// Throws an assertion error if the controller is not ready.</span>
<span id="L354"><span class="lineNum">     354</span>              :   ///</span>
<span id="L355"><span class="lineNum">     355</span>              :   /// [index] is the index of the tile in the `ExpansionTileList`.</span>
<span id="L356"><span class="lineNum">     356</span> <span class="tlaUNC">           0 :   void expand(int index) {</span></span>
<span id="L357"><span class="lineNum">     357</span> <span class="tlaUNC">           0 :     assert(_state != null, 'Error: ExpansionTileListController is not ready');</span></span>
<span id="L358"><span class="lineNum">     358</span> <span class="tlaUNC">           0 :     if (!isExpanded(index)) {</span></span>
<span id="L359"><span class="lineNum">     359</span> <span class="tlaUNC">           0 :       _state!._toggle(index);</span></span>
<span id="L360"><span class="lineNum">     360</span>              :     }</span>
<span id="L361"><span class="lineNum">     361</span>              :   }</span>
<span id="L362"><span class="lineNum">     362</span>              : </span>
<span id="L363"><span class="lineNum">     363</span>              :   /// Collapses the tile at the given index.</span>
<span id="L364"><span class="lineNum">     364</span>              :   ///</span>
<span id="L365"><span class="lineNum">     365</span>              :   /// This method programmatically collapses the tile at the specified index in the `ExpansionTileList`.</span>
<span id="L366"><span class="lineNum">     366</span>              :   /// If the tile is already collapsed, this method has no effect.</span>
<span id="L367"><span class="lineNum">     367</span>              :   ///</span>
<span id="L368"><span class="lineNum">     368</span>              :   /// [index] is the index of the tile in the `ExpansionTileList`.</span>
<span id="L369"><span class="lineNum">     369</span> <span class="tlaUNC">           0 :   void collapse(int index) {</span></span>
<span id="L370"><span class="lineNum">     370</span> <span class="tlaUNC">           0 :     assert(_state != null, 'Error: ExpansionTileListController is not ready');</span></span>
<span id="L371"><span class="lineNum">     371</span> <span class="tlaUNC">           0 :     if (isExpanded(index)) {</span></span>
<span id="L372"><span class="lineNum">     372</span> <span class="tlaUNC">           0 :       _state!._toggle(index);</span></span>
<span id="L373"><span class="lineNum">     373</span>              :     }</span>
<span id="L374"><span class="lineNum">     374</span>              :   }</span>
<span id="L375"><span class="lineNum">     375</span>              : </span>
<span id="L376"><span class="lineNum">     376</span>              :   /// Toggles the expanded state of the tile at the given index.</span>
<span id="L377"><span class="lineNum">     377</span>              :   ///</span>
<span id="L378"><span class="lineNum">     378</span>              :   /// This method programmatically toggles the expanded state of the tile at the specified index in the `ExpansionTileList`.</span>
<span id="L379"><span class="lineNum">     379</span>              :   /// If the tile is expanded, it will be collapsed; if it is collapsed, it will be expanded.</span>
<span id="L380"><span class="lineNum">     380</span>              :   ///</span>
<span id="L381"><span class="lineNum">     381</span>              :   /// [index] is the index of the tile in the `ExpansionTileList`.</span>
<span id="L382"><span class="lineNum">     382</span> <span class="tlaGNC tlaBgGNC">           1 :   void toggle(int index) {</span></span>
<span id="L383"><span class="lineNum">     383</span> <span class="tlaGNC">           1 :     assert(_state != null, 'Error: ExpansionTileListController is not ready');</span></span>
<span id="L384"><span class="lineNum">     384</span> <span class="tlaGNC">           2 :     _state!._toggle(index);</span></span>
<span id="L385"><span class="lineNum">     385</span>              :   }</span>
<span id="L386"><span class="lineNum">     386</span>              : </span>
<span id="L387"><span class="lineNum">     387</span>              :   /// Expands all the tiles in the `ExpansionTileList`.</span>
<span id="L388"><span class="lineNum">     388</span>              :   ///</span>
<span id="L389"><span class="lineNum">     389</span>              :   /// If the tiles are already expanded, this method has no effect.</span>
<span id="L390"><span class="lineNum">     390</span> <span class="tlaGNC">           1 :   void expandAll() {</span></span>
<span id="L391"><span class="lineNum">     391</span> <span class="tlaGNC">           1 :     assert(_state != null, 'Error: ExpansionTileListController is not ready');</span></span>
<span id="L392"><span class="lineNum">     392</span> <span class="tlaGNC">           2 :     _state!._toggleAll(true);</span></span>
<span id="L393"><span class="lineNum">     393</span>              :   }</span>
<span id="L394"><span class="lineNum">     394</span>              : </span>
<span id="L395"><span class="lineNum">     395</span>              :   /// Collapses all the tiles in the `ExpansionTileList`.</span>
<span id="L396"><span class="lineNum">     396</span>              :   ///</span>
<span id="L397"><span class="lineNum">     397</span>              :   /// If the tiles are already collapsed, this method has no effect.</span>
<span id="L398"><span class="lineNum">     398</span> <span class="tlaGNC">           1 :   void collapseAll() {</span></span>
<span id="L399"><span class="lineNum">     399</span> <span class="tlaGNC">           1 :     assert(_state != null, 'Error: ExpansionTileListController is not ready');</span></span>
<span id="L400"><span class="lineNum">     400</span> <span class="tlaGNC">           2 :     _state!._toggleAll(false);</span></span>
<span id="L401"><span class="lineNum">     401</span>              :   }</span>
<span id="L402"><span class="lineNum">     402</span>              : </span>
<span id="L403"><span class="lineNum">     403</span>              :   /// Finds the [ExpansionTileController] for the closest [ExpansionTile] instance</span>
<span id="L404"><span class="lineNum">     404</span>              :   /// that encloses the given context and returns it.</span>
<span id="L405"><span class="lineNum">     405</span>              :   ///</span>
<span id="L406"><span class="lineNum">     406</span>              :   /// If no [ExpansionTile] encloses the given context then return null.</span>
<span id="L407"><span class="lineNum">     407</span>              :   ///</span>
<span id="L408"><span class="lineNum">     408</span>              :   /// This method is useful when you want to access the [ExpansionTileController]</span>
<span id="L409"><span class="lineNum">     409</span>              :   /// but also want to avoid exceptions when no [ExpansionTile] is present in the</span>
<span id="L410"><span class="lineNum">     410</span>              :   /// current context. In such cases, this method will simply return null.</span>
<span id="L411"><span class="lineNum">     411</span>              :   ///</span>
<span id="L412"><span class="lineNum">     412</span>              :   /// See also:</span>
<span id="L413"><span class="lineNum">     413</span>              :   ///</span>
<span id="L414"><span class="lineNum">     414</span>              :   ///  * [of], a similar function to this one that throws if no [ExpansionTile]</span>
<span id="L415"><span class="lineNum">     415</span>              :   ///    encloses the given context.</span>
<span id="L416"><span class="lineNum">     416</span> <span class="tlaUNC tlaBgUNC">           0 :   static ExpansionTileListController? maybeOf(BuildContext context) {</span></span>
<span id="L417"><span class="lineNum">     417</span>              :     return context</span>
<span id="L418"><span class="lineNum">     418</span> <span class="tlaUNC">           0 :         .findAncestorStateOfType&lt;_ExpansionTileListState&gt;()</span></span>
<span id="L419"><span class="lineNum">     419</span> <span class="tlaUNC">           0 :         ?._listController;</span></span>
<span id="L420"><span class="lineNum">     420</span>              :   }</span>
<span id="L421"><span class="lineNum">     421</span>              : </span>
<span id="L422"><span class="lineNum">     422</span>              :   /// Finds the [ExpansionTileListController] for the closest [ExpansionTile] instance</span>
<span id="L423"><span class="lineNum">     423</span>              :   /// that encloses the given context and returns it.</span>
<span id="L424"><span class="lineNum">     424</span>              :   ///</span>
<span id="L425"><span class="lineNum">     425</span>              :   /// If no [ExpansionTile] encloses the given context, calling this</span>
<span id="L426"><span class="lineNum">     426</span>              :   /// method will cause an assert in debug mode, and throw an</span>
<span id="L427"><span class="lineNum">     427</span>              :   /// exception in release mode.</span>
<span id="L428"><span class="lineNum">     428</span>              :   ///</span>
<span id="L429"><span class="lineNum">     429</span>              :   /// This method is useful when you need to access the [ExpansionTileListController]</span>
<span id="L430"><span class="lineNum">     430</span>              :   /// and you are certain that the context is enclosed by an [ExpansionTile].</span>
<span id="L431"><span class="lineNum">     431</span>              :   /// If there's a chance that the context is not enclosed by an [ExpansionTile],</span>
<span id="L432"><span class="lineNum">     432</span>              :   /// consider using [maybeOf] method instead which returns null in such cases.</span>
<span id="L433"><span class="lineNum">     433</span>              :   ///</span>
<span id="L434"><span class="lineNum">     434</span>              :   /// See also:</span>
<span id="L435"><span class="lineNum">     435</span>              :   ///</span>
<span id="L436"><span class="lineNum">     436</span>              :   ///  * [maybeOf], a similar function to this one that returns null if no [ExpansionTile]</span>
<span id="L437"><span class="lineNum">     437</span>              :   ///    encloses the given context.</span>
<span id="L438"><span class="lineNum">     438</span> <span class="tlaUNC">           0 :   static ExpansionTileListController of(BuildContext context) {</span></span>
<span id="L439"><span class="lineNum">     439</span>              :     final _ExpansionTileListState? result =</span>
<span id="L440"><span class="lineNum">     440</span> <span class="tlaUNC">           0 :     context.findAncestorStateOfType&lt;_ExpansionTileListState&gt;();</span></span>
<span id="L441"><span class="lineNum">     441</span>              :     if (result != null) {</span>
<span id="L442"><span class="lineNum">     442</span> <span class="tlaUNC">           0 :       return result._listController;</span></span>
<span id="L443"><span class="lineNum">     443</span>              :     }</span>
<span id="L444"><span class="lineNum">     444</span> <span class="tlaUNC">           0 :     throw FlutterError.fromParts(&lt;DiagnosticsNode&gt;[</span></span>
<span id="L445"><span class="lineNum">     445</span> <span class="tlaUNC">           0 :       ErrorSummary(</span></span>
<span id="L446"><span class="lineNum">     446</span>              :         'ExpansionTileListController.of() called with a context that does not contain a ExpansionTileList.',</span>
<span id="L447"><span class="lineNum">     447</span>              :       ),</span>
<span id="L448"><span class="lineNum">     448</span> <span class="tlaUNC">           0 :       ErrorDescription(</span></span>
<span id="L449"><span class="lineNum">     449</span>              :         'No ExpansionTileList ancestor could be found starting from the context that was passed to ExpansionTileListController.of(). '</span>
<span id="L450"><span class="lineNum">     450</span>              :             'This usually happens when the context provided is from the same StatefulWidget as that '</span>
<span id="L451"><span class="lineNum">     451</span>              :             'whose build function actually creates the ExpansionTileList widget being sought.',</span>
<span id="L452"><span class="lineNum">     452</span>              :       ),</span>
<span id="L453"><span class="lineNum">     453</span> <span class="tlaUNC">           0 :       ErrorHint(</span></span>
<span id="L454"><span class="lineNum">     454</span>              :         'There are several ways to avoid this problem. The simplest is to use a Builder to get a '</span>
<span id="L455"><span class="lineNum">     455</span>              :             'context that is &quot;under&quot; the ExpansionTileList. For an example of this, please see the '</span>
<span id="L456"><span class="lineNum">     456</span>              :             'documentation for ExpansionTileListController.of():\n'</span>
<span id="L457"><span class="lineNum">     457</span>              :             '  https://api.flutter.dev/flutter/material/ExpansionTile/of.html',</span>
<span id="L458"><span class="lineNum">     458</span>              :       ),</span>
<span id="L459"><span class="lineNum">     459</span> <span class="tlaUNC">           0 :       ErrorHint(</span></span>
<span id="L460"><span class="lineNum">     460</span>              :         'A more efficient solution is to split your build function into several widgets. This '</span>
<span id="L461"><span class="lineNum">     461</span>              :             'introduces a new context from which you can obtain the ExpansionTileList. In this solution, '</span>
<span id="L462"><span class="lineNum">     462</span>              :             'you would have an outer widget that creates the ExpansionTileList populated by instances of '</span>
<span id="L463"><span class="lineNum">     463</span>              :             'your new inner widgets, and then in these inner widgets you would use ExpansionTileListController.of().\n'</span>
<span id="L464"><span class="lineNum">     464</span>              :             'An other solution is assign a GlobalKey to the ExpansionListTile, '</span>
<span id="L465"><span class="lineNum">     465</span>              :             'then use the key.currentState property to obtain the ExpansionTileList rather than '</span>
<span id="L466"><span class="lineNum">     466</span>              :             'using the ExpansionTileListController.of() function.',</span>
<span id="L467"><span class="lineNum">     467</span>              :       ),</span>
<span id="L468"><span class="lineNum">     468</span> <span class="tlaUNC">           0 :       context.describeElement('The context used was'),</span></span>
<span id="L469"><span class="lineNum">     469</span>              :     ]);</span>
<span id="L470"><span class="lineNum">     470</span>              :   }</span>
<span id="L471"><span class="lineNum">     471</span>              : }</span>
        </pre>
              </td>
            </tr>
          </table>
          <br>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="ruler"><img src="../../../glass.png" width=3 height=3 alt=""></td></tr>
            <tr><td class="versionInfo">Generated by: <a href="https://github.com//linux-test-project/lcov" target="_parent">LCOV version 2.0-1</a></td></tr>
          </table>
          <br>

</body>
</html>
